/**
* This file is part of Waarp Project.
*
* Copyright 2009, Frederic Bregier, and individual contributors by the @author tags. See the
* COPYRIGHT.txt in the distribution for a full listing of individual contributors.
*
* All Waarp Project is free software: you can redistribute it and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation, either version 3 of
* the License, or (at your option) any later version.
*
* Waarp is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
* the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
* Public License for more details.
*
* You should have received a copy of the GNU General Public License along with Waarp . If not, see
* <http://www.gnu.org/licenses/>.
*/
package org.waarp.openr66.protocol.exception;
import java.io.IOException;
import java.net.BindException;
import java.net.ConnectException;
import java.nio.channels.CancelledKeyException;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.NotYetConnectedException;
import java.util.concurrent.RejectedExecutionException;
import javax.net.ssl.SSLException;
import io.netty.channel.Channel;
import io.netty.channel.ChannelException;
import org.waarp.common.logging.WaarpLogger;
import org.waarp.common.logging.WaarpLoggerFactory;
import org.waarp.openr66.protocol.configuration.Configuration;
import org.waarp.openr66.protocol.utils.R66ShutdownHook;
/**
* Class that filter exceptions
*
* @author frederic bregier
*/
public class OpenR66ExceptionTrappedFactory {
/**
* Internal Logger
*/
private static final WaarpLogger logger = WaarpLoggerFactory
.getLogger(OpenR66ExceptionTrappedFactory.class);
/**
* @param channel
* @param throwable
* @return the OpenR66Exception corresponding to the ExceptionEvent, or null if the exception
* should be ignored
*/
public static OpenR66Exception getExceptionFromTrappedException(
Channel channel, Throwable throwable) {
final Throwable e1 = throwable;
if (e1 instanceof ConnectException) {
final ConnectException e2 = (ConnectException) e1;
logger.debug("Connection impossible since {} with Channel {}", e2
.getMessage(), channel);
return new OpenR66ProtocolNoConnectionException(
"Connection impossible", e2);
} else if (e1 instanceof ChannelException) {
final ChannelException e2 = (ChannelException) e1;
logger.info("Connection (example: timeout) impossible since {} with Channel {}",
e2.getMessage(), channel);
return new OpenR66ProtocolNetworkException(
"Connection (example: timeout) impossible", e2);
} else if (e1 instanceof CancelledKeyException) {
final CancelledKeyException e2 = (CancelledKeyException) e1;
logger.error("Connection aborted since {}", e2.getMessage());
// Is it really what we should do ?
// Yes, No action
return null;
} else if (e1 instanceof ClosedChannelException) {
logger.debug("Connection closed before end");
return new OpenR66ProtocolBusinessNoWriteBackException(
"Connection closed before end", e1);
} else if (e1 instanceof IllegalMonitorStateException) {
logger.debug("Try to release a lock incorrectly", e1);
return new OpenR66ProtocolBusinessNoWriteBackException(
"Ignored exception", e1);
} else if (e1 instanceof OpenR66ProtocolBusinessCancelException) {
final OpenR66ProtocolBusinessCancelException e2 = (OpenR66ProtocolBusinessCancelException) e1;
logger.debug("Request is canceled: {}", e2.getMessage());
return e2;
} else if (e1 instanceof OpenR66ProtocolBusinessStopException) {
final OpenR66ProtocolBusinessStopException e2 = (OpenR66ProtocolBusinessStopException) e1;
logger.debug("Request is stopped: {}", e2.getMessage());
return e2;
} else if (e1 instanceof OpenR66ProtocolBusinessQueryAlreadyFinishedException) {
final OpenR66ProtocolBusinessQueryAlreadyFinishedException e2 =
(OpenR66ProtocolBusinessQueryAlreadyFinishedException) e1;
logger.debug("Request is already finished: {}", e2.getMessage());
return e2;
} else if (e1 instanceof OpenR66ProtocolBusinessQueryStillRunningException) {
final OpenR66ProtocolBusinessQueryStillRunningException e2 =
(OpenR66ProtocolBusinessQueryStillRunningException) e1;
logger.debug("Request is still running: {}", e2.getMessage());
return e2;
} else if (e1 instanceof OpenR66ProtocolBusinessRemoteFileNotFoundException) {
final OpenR66ProtocolBusinessRemoteFileNotFoundException e2 =
(OpenR66ProtocolBusinessRemoteFileNotFoundException) e1;
logger.debug("Remote server did not find file: {}", e2.getMessage());
return e2;
} else if (e1 instanceof OpenR66ProtocolBusinessNoWriteBackException) {
final OpenR66ProtocolBusinessNoWriteBackException e2 = (OpenR66ProtocolBusinessNoWriteBackException) e1;
logger.error("Command Error Reply: {}", e2.getMessage());
return e2;
} else if (e1 instanceof OpenR66ProtocolShutdownException) {
final OpenR66ProtocolShutdownException e2 = (OpenR66ProtocolShutdownException) e1;
logger.debug("Command Shutdown {}", e2.getMessage());
return e2;
} else if (e1 instanceof OpenR66Exception) {
final OpenR66Exception e2 = (OpenR66Exception) e1;
logger.debug("Command Error Reply: {}", e2.getMessage());
return e2;
} else if (e1 instanceof BindException) {
final BindException e2 = (BindException) e1;
logger.debug("Address already in use {}", e2.getMessage());
return new OpenR66ProtocolNetworkException(
"Address already in use", e2);
} else if (e1 instanceof NotYetConnectedException) {
final NotYetConnectedException e2 = (NotYetConnectedException) e1;
logger.debug("Timeout occurs {}", e2.getMessage());
return new OpenR66ProtocolNetworkException("Timeout occurs", e2);
} else if (e1 instanceof ConnectException) {
final ConnectException e2 = (ConnectException) e1;
logger.debug("Timeout occurs {}", e2.getMessage());
return new OpenR66ProtocolNetworkException("Timeout occurs", e2);
} else if (e1 instanceof NullPointerException) {
final NullPointerException e2 = (NullPointerException) e1;
logger.error("Null pointer Exception", e2);
return new OpenR66ProtocolSystemException("Null Pointer Exception",
e2);
} else if (e1 instanceof SSLException) {
final SSLException e2 = (SSLException) e1;
logger.debug("Connection aborted since SSL Error {} with Channel {}", e2
.getMessage(), channel);
return new OpenR66ProtocolBusinessNoWriteBackException("SSL Connection aborted", e2);
} else if (e1 instanceof IOException) {
final IOException e2 = (IOException) e1;
logger.debug("Connection aborted since {} with Channel {}", e2
.getMessage(), channel);
if (channel.isActive()) {
return new OpenR66ProtocolSystemException("Connection aborted due to "
+ e2.getMessage(), e2);
} else {
return new OpenR66ProtocolBusinessNoWriteBackException("Connection aborted due to "
+ e2.getMessage(), e2);
}
} else if (e1 instanceof RejectedExecutionException) {
final RejectedExecutionException e2 = (RejectedExecutionException) e1;
logger.debug("Connection aborted since {} with Channel {}", e2
.getMessage(), channel);
if (channel.isActive()) {
return new OpenR66ProtocolSystemException("Execution aborted", e2);
} else {
return new OpenR66ProtocolBusinessNoWriteBackException("Execution aborted", e2);
}
} else if (e1 instanceof OutOfMemoryError) {
final OpenR66ProtocolShutdownException e2 = new OpenR66ProtocolShutdownException(
"Restart since OOME raized", e1);
logger.debug("Force Shutdown and Restart : {}", e2.getMessage());
if (Configuration.configuration.getR66Mib() != null) {
Configuration.configuration.getR66Mib().notifyWarning(
"OOME so shutdown and restart", e1.getMessage());
}
R66ShutdownHook.setRestart(true);
return e2;
} else {
logger.error("Unexpected exception from Outband" +
" Ref Channel: " + channel.toString(), e1);
}
if (Configuration.configuration.getR66Mib() != null) {
Configuration.configuration.getR66Mib().notifyWarning(
"Unexpected exception", e1.getMessage());
}
return new OpenR66ProtocolSystemException("Unexpected exception: " + e1.getMessage(), e1);
}
}